﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.OleDb;
using System.Configuration;
using System.Security.Cryptography;
using System.Text;
using System.Collections;
using System.Data;
using Ajax.Common;
namespace DBHelper
{
    public class DBHelper
    {
        //数据库连接字符串(web.config来配置)，可以动态更改connectionString支持多数据库.		
        public static string connectionString = PubConstant.ConnectionString;
        public DBHelper()
        {
        }


        #region 公用方法

        public static int GetMaxID(string FieldName, string TableName)
        {
            string strsql = "select max(" + FieldName + ")+1 from " + TableName;
            object obj = GetSingle(strsql);
            if (obj == null)
            {
                return 1;
            }
            else
            {
                return int.Parse(obj.ToString());
            }
        }
        public static bool Exists(string strSql)
        {
            object obj = GetSingle(strSql);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        public static bool Exists(string strSql, params OleDbParameter[] cmdParms)
        {
            object obj = GetSingle(strSql, cmdParms);
            int cmdresult;
            if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
            {
                cmdresult = 0;
            }
            else
            {
                cmdresult = int.Parse(obj.ToString());
            }
            if (cmdresult == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }

        #endregion

        #region  执行简单SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        int rows = cmd.ExecuteNonQuery();
                        return rows;
                    }
                    catch (System.Data.OleDb.OleDbException E)
                    {
                        connection.Close();
                        throw new Exception(E.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">多条SQL语句</param>		
        public static void ExecuteSqlTran(ArrayList SQLStringList)
        {
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                conn.Open();
                OleDbCommand cmd = new OleDbCommand();
                cmd.Connection = conn;
                OleDbTransaction tx = conn.BeginTransaction();
                cmd.Transaction = tx;
                try
                {
                    for (int n = 0; n < SQLStringList.Count; n++)
                    {
                        string strsql = SQLStringList[n].ToString();
                        if (strsql.Trim().Length > 1)
                        {
                            cmd.CommandText = strsql;
                            cmd.ExecuteNonQuery();
                        }
                    }
                    tx.Commit();
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    tx.Rollback();
                    throw new Exception(E.Message);
                }
            }
        }
        /// <summary>
        /// 执行带一个存储过程参数的的SQL语句。
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <param name="content">参数内容,比如一个字段是格式复杂的文章，有特殊符号，可以通过这个方式添加</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, string content)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(SQLString, connection);
                System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@content", OleDbType.VarChar);
                myParameter.Value = content;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }
        /// <summary>
        /// 向数据库里插入图像格式的字段(和上面情况类似的另一种实例)
        /// </summary>
        /// <param name="strSQL">SQL语句</param>
        /// <param name="fs">图像字节,数据库的字段类型为image的情况</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSqlInsertImg(string strSQL, byte[] fs)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(strSQL, connection);
                System.Data.OleDb.OleDbParameter myParameter = new System.Data.OleDb.OleDbParameter("@fs", OleDbType.Binary);
                myParameter.Value = fs;
                cmd.Parameters.Add(myParameter);
                try
                {
                    connection.Open();
                    int rows = cmd.ExecuteNonQuery();
                    return rows;
                }
                catch (System.Data.OleDb.OleDbException E)
                {
                    throw new Exception(E.Message);
                }
                finally
                {
                    cmd.Dispose();
                    connection.Close();
                }
            }
        }

        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand(SQLString, connection))
                {
                    try
                    {
                        connection.Open();
                        object obj = cmd.ExecuteScalar();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.OleDb.OleDbException e)
                    {
                        connection.Close();
                        throw new Exception(e.Message);
                    }
                }
            }
        }
        /// <summary>
        /// 执行查询语句，返回OleDbDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>OleDbDataReader</returns>
        public static OleDbDataReader ExecuteReader(string strSQL)
        {
            OleDbConnection connection = new OleDbConnection(connectionString);
            OleDbCommand cmd = new OleDbCommand(strSQL, connection);
            try
            {
                connection.Open();
                OleDbDataReader myReader = cmd.ExecuteReader();
                return myReader;
            }
            catch (System.Data.OleDb.OleDbException e)
            {
                throw new Exception(e.Message);
            }

        }
        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                DataSet ds = new DataSet();
                try
                {
                    connection.Open();
                    OleDbDataAdapter command = new OleDbDataAdapter(SQLString, connection);
                    command.Fill(ds, "ds");
                }
                catch (System.Data.OleDb.OleDbException ex)
                {
                    throw new Exception(ex.Message);
                }
                return ds;
            }
        }


        #endregion

        #region 执行带参数的SQL语句

        /// <summary>
        /// 执行SQL语句，返回影响的记录数
        /// </summary>
        /// <param name="SQLString">SQL语句</param>
        /// <returns>影响的记录数</returns>
        public static int ExecuteSql(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        int rows = cmd.ExecuteNonQuery();
                        cmd.Parameters.Clear();
                        return rows;
                    }
                    catch (System.Data.OleDb.OleDbException E)
                    {
                        throw new Exception(E.Message);
                    }
                }
            }
        }


        /// <summary>
        /// 执行多条SQL语句，实现数据库事务。
        /// </summary>
        /// <param name="SQLStringList">SQL语句的哈希表（key为sql语句，value是该语句的OleDbParameter[]）</param>
        public static void ExecuteSqlTran(Hashtable SQLStringList)
        {
            using (OleDbConnection conn = new OleDbConnection(connectionString))
            {
                conn.Open();
                using (OleDbTransaction trans = conn.BeginTransaction())
                {
                    OleDbCommand cmd = new OleDbCommand();
                    try
                    {
                        //循环
                        foreach (DictionaryEntry myDE in SQLStringList)
                        {
                            string cmdText = myDE.Key.ToString();
                            OleDbParameter[] cmdParms = (OleDbParameter[])myDE.Value;
                            PrepareCommand(cmd, conn, trans, cmdText, cmdParms);
                            int val = cmd.ExecuteNonQuery();
                            cmd.Parameters.Clear();

                            trans.Commit();
                        }
                    }
                    catch
                    {
                        trans.Rollback();
                        throw;
                    }
                }
            }
        }


        /// <summary>
        /// 执行一条计算查询结果语句，返回查询结果（object）。
        /// </summary>
        /// <param name="SQLString">计算查询结果语句</param>
        /// <returns>查询结果（object）</returns>
        public static object GetSingle(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                using (OleDbCommand cmd = new OleDbCommand())
                {
                    try
                    {
                        PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                        object obj = cmd.ExecuteScalar();
                        cmd.Parameters.Clear();
                        if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
                        {
                            return null;
                        }
                        else
                        {
                            return obj;
                        }
                    }
                    catch (System.Data.OleDb.OleDbException e)
                    {
                        throw new Exception(e.Message);
                    }
                }
            }
        }

        /// <summary>
        /// 执行查询语句，返回OleDbDataReader
        /// </summary>
        /// <param name="strSQL">查询语句</param>
        /// <returns>OleDbDataReader</returns>
        public static OleDbDataReader ExecuteReader(string SQLString, params OleDbParameter[] cmdParms)
        {
            OleDbConnection connection = new OleDbConnection(connectionString);
            OleDbCommand cmd = new OleDbCommand();
            try
            {
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                OleDbDataReader myReader = cmd.ExecuteReader();
                cmd.Parameters.Clear();
                return myReader;
            }
            catch (System.Data.OleDb.OleDbException e)
            {
                throw new Exception(e.Message);
            }

        }

        /// <summary>
        /// 执行查询语句，返回DataSet
        /// </summary>
        /// <param name="SQLString">查询语句</param>
        /// <returns>DataSet</returns>
        public static DataSet Query(string SQLString, params OleDbParameter[] cmdParms)
        {
            using (OleDbConnection connection = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand();
                PrepareCommand(cmd, connection, null, SQLString, cmdParms);
                using (OleDbDataAdapter da = new OleDbDataAdapter(cmd))
                {
                    DataSet ds = new DataSet();
                    try
                    {
                        da.Fill(ds, "ds");
                        cmd.Parameters.Clear();
                    }
                    catch (System.Data.OleDb.OleDbException ex)
                    {
                        throw new Exception(ex.Message);
                    }
                    return ds;
                }
            }
        }


        private static void PrepareCommand(OleDbCommand cmd, OleDbConnection conn, OleDbTransaction trans, string cmdText, OleDbParameter[] cmdParms)
        {
            if (conn.State != ConnectionState.Open)
                conn.Open();
            cmd.Connection = conn;
            cmd.CommandText = cmdText;
            if (trans != null)
                cmd.Transaction = trans;
            cmd.CommandType = CommandType.Text;//cmdType;
            if (cmdParms != null)
            {
                foreach (OleDbParameter parm in cmdParms)
                    cmd.Parameters.Add(parm);
            }
        }
        #endregion

        #region 动态对象

        /// <summary>
        /// 获取某个SQL里面的所有字段的值的对象数组
        /// </summary>
        /// <param name="sql"></param>
        /// <param name="paramName"></param>
        /// <param name="param"></param>
        /// <returns></returns>
        public static object[] GetModelValue(string sql, string[] paramName, string[] param)
        {
            ArrayList list = new ArrayList();
            using (OleDbConnection con = new OleDbConnection(connectionString))
            {
                if (con.State == ConnectionState.Closed)
                {
                    con.Open();
                }
                OleDbCommand cmd = new OleDbCommand(sql, con);
                AttachParameters(cmd, GetOleDbParameter(paramName, param));
                using (OleDbDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    // 只返回一行数据，用于前台数据更新时的数据显示
                    if (dr != null && dr.Read())
                    {
                        for (int i = 0; i < dr.FieldCount; i++)
                        {
                            list.Add(dr[i].ToString());
                        }
                    }
                }
            }
            return list.ToArray();
        }

        /// <summary>
        /// 获取一个SQL构成的动态对象
        /// </summary>
        /// <param name="sql">SQL</param>
        /// <param name="p"></param>
        /// <returns></returns>
        public static object GetSingelDynaminObject(string sql, string[] paramName, string[] param)
        {
            using (OleDbConnection con = new OleDbConnection(connectionString))
            {
                Type temp = ClassHelper.BuildType("MyDynamicObject");
                OleDbCommand cmd = new OleDbCommand(sql, con);
                AttachParameters(cmd, GetOleDbParameter(paramName, param));
                object o = ClassHelper.CreateInstance(temp);
                try
                {
                    con.Open();
                    using (OleDbDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                    {
                        List<ClassHelper.CustPropertyInfo> lists = new List<ClassHelper.CustPropertyInfo>();
                        // 使用字典存放目标属性的名称-值 eg:Address-----"西一段"
                        // 并将OleDbDataReader的字段-值填充至字典
                        Dictionary<string, string> dic = new Dictionary<string, string>();
                        for (int i = 0; i < dr.FieldCount; i++)
                        {
                            lists.Add(new ClassHelper.CustPropertyInfo(dr.GetName(i).ToUpper()));
                            dic.Add(dr.GetName(i).ToUpper(), null);
                        }
                        // 为动态类添加属性和值
                        temp = ClassHelper.AddProperty(temp, lists);
                        o = ClassHelper.CreateInstance(temp);
                        if (dr != null && dr.Read())
                        {
                            for (int j = 0; j < dic.Count; j++)
                            {
                                /// 日期类型处理。如果数据库为date类型，则返回yyyy-MM-dd格式的日期，如果为datetime类型，则返回yyyy-MM-dd hh:mm:ss
                                string dataType = dr.GetDataTypeName(j);
                                if (dataType == "date" || dataType == "datetime")
                                {
                                    if (string.IsNullOrEmpty(dr[j].ToString()))
                                    {
                                        dic[dr.GetName(j).ToUpper()] = "";
                                        continue;
                                    }
                                    if (dataType == "date")
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd");
                                    }
                                    else
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd hh:mm:ss");
                                    }
                                }
                                else
                                {
                                    dic[dr.GetName(j).ToUpper()] = dr[j].ToString();
                                }
                            }
                            o = ClassHelper.CreateInstance(temp);
                            ClassHelper.SetPropertyValue(o, dic);
                        }
                        else
                        {
                            return null;
                        }
                    }
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    throw e;
                }
                return o;
            }
        }

        /// <summary>
        /// 获取一个SQL构成的动态对象集合
        /// </summary>
        /// <param name="sql">SQL</param>
        /// <param name="p">可变参数</param>
        /// <returns>动态对象集合</returns>
        public static List<object> GetDynaminObjectList(string sql, string[] paramName, string[] param)
        {
            using (OleDbConnection con = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(sql, con);
                AttachParameters(cmd, GetOleDbParameter(paramName, param));
                List<object> dynamicList = new List<object>();
                try
                {
                    if (con.State == ConnectionState.Closed)
                        con.Open();
                    using (OleDbDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                    {
                        while (dr != null && dr.Read())
                        {
                            Type temp = ClassHelper.BuildType("MyDynamicObject");
                            object o = ClassHelper.CreateInstance(temp);
                            List<ClassHelper.CustPropertyInfo> lists = new List<ClassHelper.CustPropertyInfo>();
                            // 使用字典存放目标属性的名称-值 eg:Address-----"西一段"
                            // 并将OleDbDataReader的字段-值填充至字典
                            Dictionary<string, string> dic = new Dictionary<string, string>();
                            for (int i = 0; i < dr.FieldCount; i++)
                            {
                                lists.Add(new ClassHelper.CustPropertyInfo(dr.GetName(i).ToUpper()));
                                dic.Add(dr.GetName(i).ToUpper(), null);
                            }
                            // 为动态类添加属性和值
                            temp = ClassHelper.AddProperty(temp, lists);
                            o = ClassHelper.CreateInstance(temp);
                            for (int j = 0; j < dic.Count; j++)
                            {
                                /// 日期类型处理。如果数据库为date类型，则返回yyyy-MM-dd格式的日期，如果为datetime类型，则返回yyyy-MM-dd hh:mm:ss
                                string dataType = dr.GetDataTypeName(j);
                                if (dataType == "date" || dataType == "datetime")
                                {
                                    if (string.IsNullOrEmpty(dr[j].ToString()))
                                    {
                                        dic[dr.GetName(j).ToUpper()] = "";
                                        continue;
                                    }
                                    if (dataType == "date")
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd");
                                    }
                                    else
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd hh:mm:ss");
                                    }
                                }
                                else
                                {
                                    dic[dr.GetName(j).ToUpper()] = dr[j].ToString();
                                }
                            }
                            o = ClassHelper.CreateInstance(temp);
                            ClassHelper.SetPropertyValue(o, dic);
                            dynamicList.Add(o);
                        }
                    }
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    return dynamicList;
                }
                return dynamicList;
            }
        }

        /// <summary>
        /// 这个方法用来将命令对象和一组参数对象联系起来
        /// 
        /// This method will assign a value of DbNull to any parameter with a direction of
        /// InputOutput and a value of null.  给输出类型参数对象赋空值
        /// 
        /// This behavior will prevent default values from being used, but
        /// this will be the less common case than an intended pure output parameter (derived as InputOutput)
        /// where the user provided no input value.
        /// </summary>
        /// <param name="command">The command to which the parameters will be added</param>
        /// <param name="commandParameters">an array of OleDbParameters tho be added to command</param>
        private static void AttachParameters(OleDbCommand command, OleDbParameter[] commandParameters)
        {
            if (commandParameters != null)
            {
                foreach (OleDbParameter p in commandParameters)
                {
                    //check for derived output value with no value assigned
                    if ((p.Direction == ParameterDirection.InputOutput) && (p.Value == null))
                    {
                        p.Value = DBNull.Value;
                    }

                    command.Parameters.Add(p);
                }
            }
        }
        /// <summary>
        /// 获取OleDbParameter，参数名和参数值必须对应
        /// </summary>
        /// <param name="paramName">参数名称数组</param>
        /// <param name="p">参数值</param>
        /// <returns>OleDbParameter数组</returns>
        public static OleDbParameter[] GetOleDbParameter(string[] paramName, string[] p)
        {
            if (paramName != null && p != null)
            {
                OleDbParameter[] param = new OleDbParameter[paramName.Length];
                for (int i = 0; i < paramName.Length; i++)
                {
                    OleDbParameter temp = new OleDbParameter(paramName[i], string.IsNullOrEmpty(p[i]) ? "" : p[i]);
                    param[i] = temp;
                }
                return param;
            }
            else
                return null;
        }
        /// <summary>
        /// 获取一个SQL构成的动态对象集合
        /// </summary>
        /// <param name="sql">SQL，必须包含ID字段</param>
        /// <param name="pageIndex">当前页索引</param>
        /// <param name="pageNumber">表格显示行数</param>
        /// <param name="p">可变参数</param>
        /// <returns>动态对象集合</returns>
        public static List<object> GetDynaminObjectList(string sql, int pageIndex, int pageNumber, string orderBy, string[] paramName, string[] param)
        {
            ///获取分页数据
            string PageSQL = @"select * from 
								(SELECT *,ROW_NUMBER() OVER ( ORDER BY td.ID) AS rownumber FROM ({0}) td) temp
								WHERE rownumber BETWEEN {1} AND {2} {3}";
            PageSQL = string.Format(PageSQL, sql, pageIndex * pageNumber + 1, (pageIndex + 1) * pageNumber, orderBy == null ? "" : "order by " + orderBy);
            using (OleDbConnection con = new OleDbConnection(connectionString))
            {
                OleDbCommand cmd = new OleDbCommand(PageSQL, con);
                AttachParameters(cmd, GetOleDbParameter(paramName, param));
                List<object> dynamicList = new List<object>();
                try
                {
                    if (con.State == ConnectionState.Closed)
                        con.Open();
                    using (OleDbDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                    {
                        while (dr != null && dr.Read())
                        {
                            Type temp = ClassHelper.BuildType("MyDynamicObject");
                            object o = ClassHelper.CreateInstance(temp);
                            List<ClassHelper.CustPropertyInfo> lists = new List<ClassHelper.CustPropertyInfo>();
                            // 使用字典存放目标属性的名称-值 eg:Address-----"西一段"
                            // 并将OleDbDataReader的字段-值填充至字典
                            Dictionary<string, string> dic = new Dictionary<string, string>();
                            for (int i = 0; i < dr.FieldCount; i++)
                            {
                                lists.Add(new ClassHelper.CustPropertyInfo(dr.GetName(i).ToUpper()));
                                dic.Add(dr.GetName(i).ToUpper(), null);
                            }
                            // 为动态类添加属性和值
                            temp = ClassHelper.AddProperty(temp, lists);
                            o = ClassHelper.CreateInstance(temp);
                            for (int j = 0; j < dic.Count; j++)
                            {
                                /// 日期类型处理。如果数据库为date类型，则返回yyyy-MM-dd格式的日期，如果为datetime类型，则返回yyyy-MM-dd hh:mm:ss
                                string dataType = dr.GetDataTypeName(j);
                                if (dataType == "date" || dataType == "datetime")
                                {
                                    if (string.IsNullOrEmpty(dr[j].ToString()))
                                    {
                                        dic[dr.GetName(j).ToUpper()] = "";
                                        continue;
                                    }
                                    if (dataType == "date")
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd");
                                    }
                                    else
                                    {
                                        dic[dr.GetName(j).ToUpper()] = dr.GetDateTime(j).ToString("yyyy-MM-dd hh:mm:ss");
                                    }
                                }
                                else
                                {
                                    dic[dr.GetName(j).ToUpper()] = dr[j].ToString();
                                }
                            }
                            o = ClassHelper.CreateInstance(temp);
                            ClassHelper.SetPropertyValue(o, dic);
                            dynamicList.Add(o);
                        }
                    }
                }
                catch (System.Data.SqlClient.SqlException e)
                {
                    return dynamicList;
                }
                return dynamicList;
            }
        }
        #endregion
    }

    public class PubConstant
    {
        /// <summary>
        /// 获取连接字符串
        /// </summary>
        public static string ConnectionString
        {
            get
            {
                string strConnection = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + AppDomain.CurrentDomain.BaseDirectory + "\\bin\\lohus.mdb;Persist Security Info=False;Jet OLEDB:Database Password=rizhaolohus2012";
                return strConnection;
                //string _connectionString = ConfigurationManager.AppSettings["ConnectionString"];
                //string ConStringEncrypt = ConfigurationManager.AppSettings["ConStringEncrypt"];
                //if (ConStringEncrypt == "true")
                //{
                //    _connectionString = DESEncrypt.Decrypt(_connectionString);
                //}
                //return _connectionString;
            }
        }

        /// <summary>
        /// 得到web.config里配置项的数据库连接字符串。
        /// </summary>
        /// <param name="configName"></param>
        /// <returns></returns>
        public static string GetConnectionString(string configName)
        {
            string connectionString = ConfigurationManager.AppSettings[configName];
            string ConStringEncrypt = ConfigurationManager.AppSettings["ConStringEncrypt"];
            if (ConStringEncrypt == "true")
            {
                connectionString = DESEncrypt.Decrypt(connectionString);
            }
            return connectionString;
        }


    }

    /// <summary>
    /// DES加密/解密类。
    /// Copyright (C) Maticsoft
    /// </summary>
    public class DESEncrypt
    {
        public DESEncrypt()
        {
        }

        #region ========加密========

        /// <summary>
        /// 加密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Encrypt(string Text)
        {
            return Encrypt(Text, "MATICSOFT");
        }
        /// <summary> 
        /// 加密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Encrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            byte[] inputByteArray;
            inputByteArray = Encoding.Default.GetBytes(Text);
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            StringBuilder ret = new StringBuilder();
            foreach (byte b in ms.ToArray())
            {
                ret.AppendFormat("{0:X2}", b);
            }
            return ret.ToString();
        }

        #endregion

        #region ========解密========


        /// <summary>
        /// 解密
        /// </summary>
        /// <param name="Text"></param>
        /// <returns></returns>
        public static string Decrypt(string Text)
        {
            return Decrypt(Text, "MATICSOFT");
        }
        /// <summary> 
        /// 解密数据 
        /// </summary> 
        /// <param name="Text"></param> 
        /// <param name="sKey"></param> 
        /// <returns></returns> 
        public static string Decrypt(string Text, string sKey)
        {
            DESCryptoServiceProvider des = new DESCryptoServiceProvider();
            int len;
            len = Text.Length / 2;
            byte[] inputByteArray = new byte[len];
            int x, i;
            for (x = 0; x < len; x++)
            {
                i = Convert.ToInt32(Text.Substring(x * 2, 2), 16);
                inputByteArray[x] = (byte)i;
            }
            des.Key = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            des.IV = ASCIIEncoding.ASCII.GetBytes(System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(sKey, "md5").Substring(0, 8));
            System.IO.MemoryStream ms = new System.IO.MemoryStream();
            CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
            cs.Write(inputByteArray, 0, inputByteArray.Length);
            cs.FlushFinalBlock();
            return Encoding.Default.GetString(ms.ToArray());
        }

        #endregion


    }
}